#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 6

// 数组移动后，之前的空间不需要删，这是数组，空间已经分配过了的。
// 固定不变，下次赋值就会把里面值覆盖

typedef struct Queue
{
    // 数组位置
    int *pBase;
    // f永远是队列第一个位置
    int front;
    // r指向最后一个有效位置的下一位
    int rear;
} QUEUE, *PQUEUE;

void init(PQUEUE);              //初始化
bool en_queue(PQUEUE, int val); //入队
void traverse_queue(PQUEUE);    //遍历
bool full_queue(PQUEUE);        //是否满
bool out_queue(QUEUE *, int *); //出队
bool empty_queue(QUEUE *);      //是否为空

int main()
{
    QUEUE Q;
    int val;
    init(&Q);
    en_queue(&Q, 1);
    en_queue(&Q, 2);
    en_queue(&Q, 3);
    en_queue(&Q, 4);
    en_queue(&Q, 5);
    traverse_queue(&Q);
    if (out_queue(&Q, &val))
    {
        printf("出队成功，队列出队的元素是: %d\n", val);
    }
    else
    {
        printf("出队失败!\n");
    }
    traverse_queue(&Q);
    return 0;
}

// 初始化队列
void init(PQUEUE pQ)
{
    pQ->pBase = (int *)malloc(sizeof(int) * MAXSIZE);
    pQ->front = 0;
    pQ->rear = 0;
}

// 入队
bool en_queue(PQUEUE pQ, int val)
{
    if (full_queue(pQ))
    {
        return false;
    }
    else
    {
        pQ->pBase[pQ->rear] = val;
        pQ->rear = (pQ->rear + 1) % MAXSIZE;
        return true;
    }
}

//出队
bool out_queue(PQUEUE pQ, int *val)
{
    if (empty_queue(pQ))
    {
        return false;
    }
    else
    {
        *val = pQ->pBase[pQ->front];
        pQ->front = (pQ->front + 1) % MAXSIZE;
        return true;
    }
}

// 遍历
void traverse_queue(PQUEUE pQ)
{
    int i = pQ->front;

    while (i != pQ->rear)
    {
        printf("%d  ", pQ->pBase[i]);
        i = (i + 1) % MAXSIZE;
    }
    printf("\n");

    return;
}

//取队头
void getHead(PQUEUE pQ)
{
    if (empty_queue)
    {
        return;
    }
    else
    {
        printf("%d", pQ->pBase[pQ->front]);
    }
}

//队伍的长度
void queue_length(PQUEUE pQ)
{
    return (pQ->rear - pQ->front + MAXSIZE) % MAXSIZE;
}

// 队满
bool full_queue(PQUEUE pQ)
{

    return (pQ->rear + 1) % MAXSIZE == pQ->front ? true : false;
}

//是否为空
bool empty_queue(PQUEUE pQ)
{
    if (pQ->front == pQ->rear)
    {
        return true;
    }
    else
    {
        return false;
    }
}
